// var obj = {
//     name: '丑弟',
//     getName: function() {
//         console.log(this.name)
//     },
// }

// obj.getName()
// var b = obj.getName
// b()

// var array = [1, [2],
//     [3, [4, [5]]]
// ]

// function flatten(arr) {
//     var res = [];
//     arr.map(item => {
//         if (Array.isArray(item)) {
//             res = res.concat(flatten(item));
//         } else {
//             res.push(item);
//         }
//     });
//     return res;
// }
// console.log(flatten(array))

function LinkedList(value) {
    this.value = value;
    this.next = null
}

const a = new LinkedList(1)
const b = new LinkedList(2)
const c = new LinkedList(3)

a.next = b
b.next = c

设计实现一个lRU（最近最少使用）缓存机制

支持获取数据， 写入数据

- 获取数据get(key) - 如果秘钥存在于缓存中 ==> 获取返回秘钥，如果没有返回-1
- 写入数据put(key,value) 如果秘钥不存在 ==> 写入数据
> 如果缓存容量达到上限， 先删除最久未使用的数据， 在次写入，保证不超缓存上限

// console.log(a)

// while(a){
//     console.log(a.value)
//     a = a.next
// }

// function link(head) {
//     if(head == null) return
//     console.log(head.value)
//     link(head.next)
// }

// link(a)

var reverseList = function (head) {
    debugger
    if (!head || !head.next) return head
    var prev = null, curr = head
    while (curr) {
        // 用于临时存储 curr 后继节点
        var next = curr.next
        // 反转 curr 的后继指针
        curr.next = prev
        // 变更prev、curr 
        // 待反转节点指向下一个节点 
        prev = curr
        curr = next
    }
    head = prev
    return head
};


// console.log(reverseList(a))

/**
 * 构建一个1->2->3->4->5的链表
 * 将链表反转，遍历反转后链表
 */

function Node(value) {
    this.value = value;
    this.next = null;
}

var node1 = new Node(1);
var node2 = new Node(2);
var node3 = new Node(3);
var node4 = new Node(4);
var node5 = new Node(5);

node1.next = node2;
node2.next = node3;
node3.next = node4;
node4.next = node5;

function nizhi2(head) {
    // 找最后一个节点
    if (head.next.next == null) {
        root.next.next = root
        return root.next
    } else {
        var result = nizhi2(root.next);
        root.next.next = root
        root.next = null;
        return result
    }
}
function getRootLast(head) { 
    if (head.next !== null) return getRootLast(head.next); 
    else return head 
}

function nizhi(root) {
    if (root.next.next == null) {//代表当前节点是倒数第二个节点
        // 最后一个节点
      	var lastNode = root.next 
        lastNode.next = root;   // 让最后一个节点的next指向自己（倒数第二个节点）
        return lastNode;   // 返回反转后的root节点
    } else { // 如果不是倒数第二个，就向后查找
        var result = nizhi(root.next);
        // 当前节点的下下个元素指向当前
        root.next.next = root;
        // 给当前的节点的next指空， 否则原来第一个节点的next还是指向原来第二个节点，导致遍历死循环
        root.next = null;
        return result;
    }
}



var newRoot = nizhi(node1);

while(newRoot){
    console.log(newRoot.value);
    newRoot = newRoot.next
}

// function bianLink(root) {
//     if (root == null) return;
//     console.log(root.value);
//     bianLink(root.next);
// }
// bianLink(newRoot);